Skip to content

Closes #127 - the new structure is now taken into account.#135

Merged
eljonny merged 1 commit intomainfrom
update-clang-tidy-and-msvc-with-git-submodules-include-paths
Jun 9, 2025
Merged

Closes #127 - the new structure is now taken into account.#135
eljonny merged 1 commit intomainfrom
update-clang-tidy-and-msvc-with-git-submodules-include-paths

Conversation

@eljonny
Copy link
Owner

@eljonny eljonny commented Jun 9, 2025

Updates the clang-tidy config and the MSVC builds.

@eljonny eljonny added this to the 0.5-release milestone Jun 9, 2025
@eljonny eljonny self-assigned this Jun 9, 2025
@eljonny eljonny added bug Something isn't working static-analysis An issue related to a static analysis result ci-cd Relates to CI/CD for the project cmake Applicable to issues that are relavent to the CMake build labels Jun 9, 2025
@github-actions
Copy link

github-actions bot commented Jun 9, 2025

⚡ Static analysis result ⚡

🔴 clang-tidy found 191 issues! Click here to see details.

TestCPP/src/TestCPPExceptions.cpp

Lines 28 to 33 in a510014

#include <iostream>
#include "internal/TestCPPExceptions.h"
#ifdef TESTCPP_STACKTRACE_ENABLED
#include <boost/stacktrace.hpp> 

!Line: 28 - error: included header iostream is not used directly [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPExceptions.cpp

Lines 37 to 42 in a510014

using std::string;
using std::runtime_error;
namespace TestCPP {
TestCPPException::TestCPPException (const char * msg) : 

!Line: 37 - error: no header providing "std::string" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPExceptions.cpp

Lines 38 to 43 in a510014

using std::runtime_error;
namespace TestCPP {
TestCPPException::TestCPPException (const char * msg) :
runtime_error(msg) 

!Line: 38 - error: no header providing "std::runtime_error" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPExceptions.cpp

Lines 66 to 71 in a510014

TestCPPException(std::move(msg))
{
#ifdef TESTCPP_STACKTRACE_ENABLED
clog << boost::stacktrace::stacktrace();
#endif
} 

!Line: 66 - error: std::move of the const variable 'msg' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 49 - note: consider changing the 1st parameter of 'TestCPPException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPExceptions.cpp

Lines 66 to 71 in a510014

TestCPPException(std::move(msg))
{
#ifdef TESTCPP_STACKTRACE_ENABLED
clog << boost::stacktrace::stacktrace();
#endif
} 

!Line: 66 - error: no header providing "std::move" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/include/internal/TestCPPCommon.h

Lines 88 to 93 in a510014

static constexpr const char * SP = " ";
static constexpr const char * START_RUN =
"Starting run of test ";
static constexpr const char * SUITE = "Suite ";
static constexpr const char * SUITE_TESTS_PASSED =
" suite tests passed!"; 

!Line: 88 - error: variable name 'SP' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 73 to 78 in a510014

TestObjName (const char* name);
/**
* @brief Get the encapsulated name for the TestCPP object that
* holds this object.
* @return The name of the TestCPP object that this object 

!Line: 73 - error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [hicpp-explicit-conversions,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 81 to 86 in a510014

const string& getName () const;
/**
* @brief Output the test object name to the specified stream.
* @param s The stream to output to.
* @param tcName The test object name object. 

!Line: 81 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 89 to 94 in a510014

friend std::ostream& operator<< (
std::ostream& s,
const TestObjName& tcName
);
private: 

!Line: 89 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 90 to 95 in a510014

std::ostream& s,
const TestObjName& tcName
);
private:
string testCaseName; 

!Line: 90 - error: parameter name 's' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 106 to 111 in a510014

template <class T> class no_destroy {
// Flawfinder: ignore
alignas(T) unsigned char data[sizeof(T)];
public:
template <class... Ts> no_destroy(Ts&&... ts) { new (data) T(std::forward<Ts>(ts)...); }
T& get() { return *reinterpret_cast<T*>(data); } 

!Line: 106 - error: constructor does not initialize these fields: data [cppcoreguidelines-pro-type-member-init,hicpp-member-init,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 108 to 113 in a510014

alignas(T) unsigned char data[sizeof(T)];
public:
template <class... Ts> no_destroy(Ts&&... ts) { new (data) T(std::forward<Ts>(ts)...); }
T& get() { return *reinterpret_cast<T*>(data); }
}; 

!Line: 108 - error: do not declare C-style arrays, use 'std::array' instead [cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 110 to 115 in a510014

template <class... Ts> no_destroy(Ts&&... ts) { new (data) T(std::forward<Ts>(ts)...); }
T& get() { return *reinterpret_cast<T*>(data); }
};
/**
* @brief Log a message that will only be output when debug 

!Line: 110 - error: constructor does not initialize these fields: data [cppcoreguidelines-pro-type-member-init,hicpp-member-init,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 110 to 115 in a510014

template <class... Ts> no_destroy(Ts&&... ts) { new (data) T(std::forward<Ts>(ts)...); }
T& get() { return *reinterpret_cast<T*>(data); }
};
/**
* @brief Log a message that will only be output when debug 

!Line: 110 - error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [hicpp-explicit-conversions,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 110 to 115 in a510014

template <class... Ts> no_destroy(Ts&&... ts) { new (data) T(std::forward<Ts>(ts)...); }
T& get() { return *reinterpret_cast<T*>(data); }
};
/**
* @brief Log a message that will only be output when debug 

!Line: 110 - error: parameter name 'ts' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 111 to 116 in a510014

T& get() { return *reinterpret_cast<T*>(data); }
};
/**
* @brief Log a message that will only be output when debug
* logging is enabled. 

!Line: 111 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 111 to 116 in a510014

T& get() { return *reinterpret_cast<T*>(data); }
};
/**
* @brief Log a message that will only be output when debug
* logging is enabled. 

!Line: 111 - error: do not use reinterpret_cast [cppcoreguidelines-pro-type-reinterpret-cast,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 137 to 142 in a510014

bool stringContains (const string& source,
const string& contains);
/**
* @brief Safely converts unsigned integer values to signed.
* @param toCast The unsigned value to convert. 

!Line: 137 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 145 to 149 in a510014

int unsignedToSigned(unsigned toCast);
}
}
#endif 

!Line: 145 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 51 to 56 in a510014

if (name) {
this->testCaseName = name;
}
else {
throw TestCPPException(TCPPStr::NVTN);
} 

!Line: 51 - error: implicit conversion 'const char *' -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 59 to 64 in a510014

const string& TestObjName::getName () const {
return this->testCaseName;
}
std::ostream& operator<< (
std::ostream& s, 

!Line: 59 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 63 to 68 in a510014

std::ostream& operator<< (
std::ostream& s,
const TestObjName& tcName
)
{
s << tcName.getName(); 

!Line: 63 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 64 to 69 in a510014

std::ostream& s,
const TestObjName& tcName
)
{
s << tcName.getName();
return s; 

!Line: 64 - error: parameter name 's' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 78 to 83 in a510014

clog << endl;
}
#endif
}
bool stringContains(const string& source, 

!Line: 78 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 83 to 88 in a510014

bool stringContains(const string& source,
const string& contains)
{
return source.find(contains) != string::npos;
} 

!Line: 83 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 89 to 94 in a510014

int unsignedToSigned(unsigned toCast) {
if (toCast <= INT_MAX) {
return static_cast<int>(toCast);
}
if (toCast >= static_cast<unsigned>(INT_MIN)) { 

!Line: 89 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 84 to 89 in a510014

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
/** 

!Line: 84 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 85 to 90 in a510014

throw TestFailedException(std::move(err));
}
}
/**
* @brief Check that something is not equivalent to something 

!Line: 85 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/include/internal/TestCPPAssertions.h

Lines 110 to 115 in a510014

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
/** 

!Line: 110 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 111 to 116 in a510014

throw TestFailedException(std::move(err));
}
}
/**
* @brief Check that a pointer is null. 

!Line: 111 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/include/internal/TestCPPAssertions.h

Lines 131 to 136 in a510014

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
/** 

!Line: 131 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 132 to 137 in a510014

throw TestFailedException(std::move(err));
}
}
/**
* @brief Check that a pointer is non-null. 

!Line: 132 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/include/internal/TestCPPAssertions.h

Lines 152 to 157 in a510014

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
/** 

!Line: 152 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 153 to 158 in a510014

throw TestFailedException(std::move(err));
}
}
/**
* @brief Verify that a function throws something. 

!Line: 153 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/include/internal/TestCPPAssertions.h

Lines 243 to 248 in a510014

static const string logTestFailure(
T1 expectationValue, T2 actual,
const string& assertionTypeMessage,
const string& failureMessage,
const bool logValues
) 

!Line: 243 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 243 to 248 in a510014

static const string logTestFailure(
T1 expectationValue, T2 actual,
const string& assertionTypeMessage,
const string& failureMessage,
const bool logValues
) 

!Line: 243 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 252 to 257 in a510014

err << assertionTypeMessage << endl;
err << failureMessage << endl;
if (logValues) {
err << "Expectation value: <" << expectationValue << ">"
<< endl; 

!Line: 252 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 253 to 258 in a510014

err << failureMessage << endl;
if (logValues) {
err << "Expectation value: <" << expectationValue << ">"
<< endl;
err << "Actual: <" << actual << ">" << endl; 

!Line: 253 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 265 to 270 in a510014

static const string checkEquals(
T1 expected, T2 actual,
const string& failureMessage
)
{
if (expected != actual) { 

!Line: 265 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 265 to 270 in a510014

static const string checkEquals(
T1 expected, T2 actual,
const string& failureMessage
)
{
if (expected != actual) { 

!Line: 265 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 282 to 287 in a510014

static const string checkNotEquals(
T1 shouldNotBe, T2 actual,
const string& failureMessage
)
{
if (shouldNotBe == actual) { 

!Line: 282 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 282 to 287 in a510014

static const string checkNotEquals(
T1 shouldNotBe, T2 actual,
const string& failureMessage
)
{
if (shouldNotBe == actual) { 

!Line: 282 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 299 to 304 in a510014

static const string checkNull(
T ptr,
const string& failureMessage
)
{
bool null = ptr == nullptr; 

!Line: 299 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 299 to 304 in a510014

static const string checkNull(
T ptr,
const string& failureMessage
)
{
bool null = ptr == nullptr; 

!Line: 299 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 318 to 323 in a510014

static const string checkNotNull(
T ptr,
const string& failureMessage
)
{
bool notNull = ptr != nullptr; 

!Line: 318 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 318 to 323 in a510014

static const string checkNotNull(
T ptr,
const string& failureMessage
)
{
bool notNull = ptr != nullptr; 

!Line: 318 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 387 to 392 in a510014

const string TestCPP::Assertions::checkEquals<const char*, const char*>(
const char* expected, const char* actual,
const string& failureMessage
);
template<> 

!Line: 387 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 393 to 398 in a510014

const string TestCPP::Assertions::checkNotEquals<const char*, const char*>(
const char* shouldNotBe, const char* actual,
const string& failureMessage
);
#endif 

!Line: 393 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 30 to 35 in a510014

using std::clog;
using std::current_exception;
using std::endl;
using std::exception;
using std::exception_ptr;
using std::function; 

!Line: 30 - error: no header providing "std::clog" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 31 to 36 in a510014

using std::current_exception;
using std::endl;
using std::exception;
using std::exception_ptr;
using std::function;
using std::rethrow_exception; 

!Line: 31 - error: no header providing "std::current_exception" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 33 to 38 in a510014

using std::exception;
using std::exception_ptr;
using std::function;
using std::rethrow_exception;
using std::string;
using std::stringstream; 

!Line: 33 - error: no header providing "std::exception" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 34 to 39 in a510014

using std::exception_ptr;
using std::function;
using std::rethrow_exception;
using std::string;
using std::stringstream; 

!Line: 34 - error: no header providing "std::__exception_ptr::exception_ptr" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 35 to 40 in a510014

using std::function;
using std::rethrow_exception;
using std::string;
using std::stringstream;
namespace TestCPP { 

!Line: 35 - error: no header providing "std::function" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 36 to 41 in a510014

using std::rethrow_exception;
using std::string;
using std::stringstream;
namespace TestCPP { 

!Line: 36 - error: no header providing "std::rethrow_exception" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 37 to 42 in a510014

using std::string;
using std::stringstream;
namespace TestCPP {
template<> 

!Line: 37 - error: no header providing "std::string" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 38 to 43 in a510014

using std::stringstream;
namespace TestCPP {
template<>
const string Assertions::checkEquals<const char*, const char*>( 

!Line: 38 - error: no header providing "std::stringstream" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 43 to 48 in a510014

const string Assertions::checkEquals<const char*, const char*>(
const char* expected, const char* actual,
const string& failureMessage
)
{
if (strcmp(expected, actual)) { 

!Line: 43 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 43 to 48 in a510014

const string Assertions::checkEquals<const char*, const char*>(
const char* expected, const char* actual,
const string& failureMessage
)
{
if (strcmp(expected, actual)) { 

!Line: 43 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 48 to 53 in a510014

if (strcmp(expected, actual)) {
return logTestFailure(
expected, actual,
equivalenceAssertionMessage,
failureMessage,
true 

!Line: 48 - error: function 'strcmp' is called without explicitly comparing result [bugprone-suspicious-string-compare,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 48 to 53 in a510014

if (strcmp(expected, actual)) {
return logTestFailure(
expected, actual,
equivalenceAssertionMessage,
failureMessage,
true 

!Line: 48 - error: no header providing "strcmp" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 48 to 53 in a510014

if (strcmp(expected, actual)) {
return logTestFailure(
expected, actual,
equivalenceAssertionMessage,
failureMessage,
true 

!Line: 48 - error: implicit conversion 'int' -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 60 to 65 in a510014

const string Assertions::checkNotEquals<const char*, const char*>(
const char* shouldNotBe, const char* actual,
const string& failureMessage
)
{
if (!strcmp(shouldNotBe, actual)) { 

!Line: 60 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 60 to 65 in a510014

const string Assertions::checkNotEquals<const char*, const char*>(
const char* shouldNotBe, const char* actual,
const string& failureMessage
)
{
if (!strcmp(shouldNotBe, actual)) { 

!Line: 60 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 65 to 70 in a510014

if (!strcmp(shouldNotBe, actual)) {
return logTestFailure(
shouldNotBe, actual,
nonequivalenceAssertionMessage,
failureMessage,
true 

!Line: 65 - error: implicit conversion 'int' -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 83 to 88 in a510014

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
template<> 

!Line: 83 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 83 to 88 in a510014

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
template<> 

!Line: 83 - error: implicit conversion 'size_type' (aka 'unsigned long') -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 84 to 89 in a510014

throw TestFailedException(std::move(err));
}
}
template<>
void Assertions::assertNotEquals<const char*, const char*>( 

!Line: 84 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPAssertions.cpp

Lines 84 to 89 in a510014

throw TestFailedException(std::move(err));
}
}
template<>
void Assertions::assertNotEquals<const char*, const char*>( 

!Line: 84 - error: no header providing "std::move" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 96 to 101 in a510014

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
void Assertions::assertThrows ( 

!Line: 96 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 96 to 101 in a510014

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
void Assertions::assertThrows ( 

!Line: 96 - error: implicit conversion 'size_type' (aka 'unsigned long') -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 97 to 102 in a510014

throw TestFailedException(std::move(err));
}
}
void Assertions::assertThrows (
function<void()> shouldThrow, 

!Line: 97 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPAssertions.cpp

Lines 102 to 107 in a510014

function<void()> shouldThrow,
const string& failureMessage
)
{
try {
shouldThrow(); 

!Line: 102 - error: the parameter 'shouldThrow' is copied for each invocation but only used as a const reference; consider making it a const reference [performance-unnecessary-value-param,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 110 to 115 in a510014

exception_ptr eptr = current_exception();
if (eptr) {
try {
rethrow_exception(eptr);
} 

!Line: 110 - error: variable 'eptr' of type 'exception_ptr' can be declared 'const' [misc-const-correctness,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 119 to 124 in a510014

<< endl;
}
}
else {
clog << "Something was thrown, not sure what." << endl
<< "This satisfies the assertion, so no failure is" 

!Line: 119 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 123 to 128 in a510014

clog << "Something was thrown, not sure what." << endl
<< "This satisfies the assertion, so no failure is"
<< " present. "
<< TestFailedException("Unknown thrown object").
what();
} 

!Line: 123 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 133 to 138 in a510014

throw TestFailedException(std::move(failureMessage));
}
void Assertions::assertNoThrows (
const function<void()>& shouldNotThrow,
const string& failureMessage 

!Line: 133 - error: std::move of the const variable 'failureMessage' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPAssertions.cpp

Lines 145 to 150 in a510014

throw TestFailedException(std::move(failureMessage));
}
}
void Assertions::assertTrue (
bool condition, 

!Line: 145 - error: std::move of the const variable 'failureMessage' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPAssertions.cpp

Lines 164 to 169 in a510014

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
} 

!Line: 164 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 164 to 169 in a510014

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
} 

!Line: 164 - error: implicit conversion 'size_type' (aka 'unsigned long') -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 165 to 170 in a510014

throw TestFailedException(std::move(err));
}
}
}
void Assertions::assertFalse ( 

!Line: 165 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPAssertions.cpp

Lines 185 to 190 in a510014

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
} 

!Line: 185 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 185 to 190 in a510014

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
} 

!Line: 185 - error: implicit conversion 'size_type' (aka 'unsigned long') -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 186 to 191 in a510014

throw TestFailedException(std::move(err));
}
}
}
[[noreturn]] void Assertions::fail(string failureMessage) { 

!Line: 186 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPAssertions.cpp

Lines 191 to 194 in a510014

[[noreturn]] void Assertions::fail(string failureMessage) {
throw TestFailedException(std::move(failureMessage));
}
} 

!Line: 191 - error: the parameter 'failureMessage' is copied for each invocation but only used as a const reference; consider making it a const reference [performance-unnecessary-value-param,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 192 to 194 in a510014

throw TestFailedException(std::move(failureMessage));
}
} 

!Line: 192 - error: no header providing "std::move" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 92 to 97 in a510014

enum TestCaseOutCompareOptions {
CONTAINS,
EXACT
};
/** 

!Line: 92 - error: enum 'TestCaseOutCompareOptions' uses a larger base type ('unsigned int', size: 4 bytes) than necessary for its value set, consider using 'std::uint8_t' (1 byte) as the base type to reduce its size [performance-enum-size,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 146 to 151 in a510014

TestCase (const TestCase& o);
/**
* @brief Construct a TestCase by moving all data from another
* TestCase.
* @param o Move everything from this TestCase into the new one. 

!Line: 146 - error: parameter name 'o' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 153 to 158 in a510014

TestCase (TestCase&& o) noexcept;
/**
* @brief Copy a TestCase into another TestCase.
* @param rhs The test case to copy from.
* @return A reference to the new TestCase copy. 

!Line: 153 - error: parameter name 'o' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 160 to 165 in a510014

TestCase& operator= (const TestCase& rhs);
/**
* @brief Move a TestCase into another TestCase.
* @param rhs Move everything from this TestCase into the new
* one. 

!Line: 160 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 169 to 174 in a510014

TestCase& operator= (TestCase&& rhs) noexcept;
/**
* @brief Destroy a TestCase object.
*/
~TestCase (); 

!Line: 169 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 224 to 229 in a510014

bool checkStdout (const string& against);
/**
* @brief Check the argument against what is captured from
* std::clog using the configured comparison mode.
* @param against The value to check the captured output against 

!Line: 224 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 233 to 238 in a510014

bool checkLog (const string& against);
/**
* @brief Check the argument against what is captured from
* stderr using the configured comparison mode.
* @param against The value to check the captured output against 

!Line: 233 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 243 to 248 in a510014

bool checkStderr (const string& against);
/**
* @brief Run the test case.
* @return True if the test ran successfully, false otherwise.
*/ 

!Line: 243 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 249 to 254 in a510014

bool go ();
/**
* @brief Returns the duration of the last run in nanoseconds.
* @return The duration of the last run of this TestCase in
* nanoseconds. 

!Line: 249 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 256 to 261 in a510014

long long getLastRuntime () const;
private:
bool notifyTestPassed = false;
bool pass = false;
bool stdoutCaptured = false; 

!Line: 256 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 315 to 320 in a510014

bool checkOutput (const string& source, const string& against);
static atomic_int stdoutCaptureCasesConstructed;
static atomic_int logCaptureCasesConstructed;
static atomic_int stderrCaptureCasesConstructed;
static atomic_int stdoutCaptureCasesDestroyed; 

!Line: 315 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 345 to 350 in a510014

static nanoseconds duration (const F& func, Args&&... args)
{
auto start = system_clock::now();
func(forward<Args>(args)...);
return duration_cast<nanoseconds>(
system_clock::now() - start 

!Line: 345 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 110 to 115 in a510014

template <class... Ts> no_destroy(Ts&&... ts) { new (data) T(std::forward<Ts>(ts)...); }
T& get() { return *reinterpret_cast<T*>(data); }
};
/**
* @brief Log a message that will only be output when debug 

!Line: 110 - error: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay,hicpp-no-array-decay,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 45 to 50 in a510014

using std::cerr;
using std::clog;
using std::cout;
using std::endl;
using std::exception;
using std::fixed; 

!Line: 45 - error: no header providing "std::cerr" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 46 to 51 in a510014

using std::clog;
using std::cout;
using std::endl;
using std::exception;
using std::fixed;
using std::function; 

!Line: 46 - error: no header providing "std::clog" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 47 to 52 in a510014

using std::cout;
using std::endl;
using std::exception;
using std::fixed;
using std::function;
using std::invalid_argument; 

!Line: 47 - error: no header providing "std::cout" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 49 to 54 in a510014

using std::exception;
using std::fixed;
using std::function;
using std::invalid_argument;
using std::rethrow_exception;
using std::runtime_error; 

!Line: 49 - error: no header providing "std::exception" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 50 to 55 in a510014

using std::fixed;
using std::function;
using std::invalid_argument;
using std::rethrow_exception;
using std::runtime_error;
using std::setprecision; 

!Line: 50 - error: no header providing "std::fixed" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 51 to 56 in a510014

using std::function;
using std::invalid_argument;
using std::rethrow_exception;
using std::runtime_error;
using std::setprecision;
using std::string; 

!Line: 51 - error: no header providing "std::function" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 52 to 57 in a510014

using std::invalid_argument;
using std::rethrow_exception;
using std::runtime_error;
using std::setprecision;
using std::string;
using std::tuple; 

!Line: 52 - error: no header providing "std::invalid_argument" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 52 to 57 in a510014

using std::invalid_argument;
using std::rethrow_exception;
using std::runtime_error;
using std::setprecision;
using std::string;
using std::tuple; 

!Line: 52 - error: using decl 'invalid_argument' is unused [misc-unused-using-decls,-warnings-as-errors]

!Line: 52 - note: remove the using

TestCPP/src/TestCPPTestCase.cpp

Lines 53 to 58 in a510014

using std::rethrow_exception;
using std::runtime_error;
using std::setprecision;
using std::string;
using std::tuple; 

!Line: 53 - error: no header providing "std::rethrow_exception" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 53 to 58 in a510014

using std::rethrow_exception;
using std::runtime_error;
using std::setprecision;
using std::string;
using std::tuple; 

!Line: 53 - error: using decl 'rethrow_exception' is unused [misc-unused-using-decls,-warnings-as-errors]

!Line: 53 - note: remove the using

TestCPP/src/TestCPPTestCase.cpp

Lines 54 to 59 in a510014

using std::runtime_error;
using std::setprecision;
using std::string;
using std::tuple;
using TCPPNum = TestCPP::TestCPPCommon::Nums; 

!Line: 54 - error: no header providing "std::runtime_error" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 54 to 59 in a510014

using std::runtime_error;
using std::setprecision;
using std::string;
using std::tuple;
using TCPPNum = TestCPP::TestCPPCommon::Nums; 

!Line: 54 - error: using decl 'runtime_error' is unused [misc-unused-using-decls,-warnings-as-errors]

!Line: 54 - note: remove the using

TestCPP/src/TestCPPTestCase.cpp

Lines 56 to 61 in a510014

using std::string;
using std::tuple;
using TCPPNum = TestCPP::TestCPPCommon::Nums;
using TCPPStr = TestCPP::TestCPPCommon::Strings; 

!Line: 56 - error: no header providing "std::string" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 57 to 62 in a510014

using std::tuple;
using TCPPNum = TestCPP::TestCPPCommon::Nums;
using TCPPStr = TestCPP::TestCPPCommon::Strings;
namespace TestCPP { 

!Line: 57 - error: no header providing "std::tuple" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 57 to 62 in a510014

using std::tuple;
using TCPPNum = TestCPP::TestCPPCommon::Nums;
using TCPPStr = TestCPP::TestCPPCommon::Strings;
namespace TestCPP { 

!Line: 57 - error: using decl 'tuple' is unused [misc-unused-using-decls,-warnings-as-errors]

!Line: 57 - note: remove the using

TestCPP/src/TestCPPTestCase.cpp

Lines 64 to 69 in a510014

atomic_int TestCase::stdoutCaptureCasesConstructed;
atomic_int TestCase::logCaptureCasesConstructed;
atomic_int TestCase::stderrCaptureCasesConstructed;
atomic_int TestCase::stdoutCaptureCasesDestroyed;
atomic_int TestCase::logCaptureCasesDestroyed;
atomic_int TestCase::stderrCaptureCasesDestroyed; 

!Line: 64 - error: no header providing "atomic_int" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 72 to 77 in a510014

TestCase::stdoutBuffer =
no_destroy<unique_ptr<stringstream, void(*)(stringstream*)>>(
unique_ptr<stringstream, void(*)(stringstream*)>(
nullptr, [](stringstream*){}
)
); 

!Line: 72 - error: initialization of 'stdoutBuffer' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp,-warnings-as-errors]

!Line: 110 - note: possibly throwing constructor declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 79 to 84 in a510014

TestCase::clogBuffer =
no_destroy<unique_ptr<stringstream, void(*)(stringstream*)>>(
unique_ptr<stringstream, void(*)(stringstream*)>(
nullptr, [](stringstream*){}
)
); 

!Line: 79 - error: initialization of 'clogBuffer' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp,-warnings-as-errors]

!Line: 110 - note: possibly throwing constructor declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 86 to 91 in a510014

TestCase::stderrBuffer =
no_destroy<unique_ptr<stringstream, void(*)(stringstream*)>>(
unique_ptr<stringstream, void(*)(stringstream*)>(
nullptr, [](stringstream*){}
)
); 

!Line: 86 - error: initialization of 'stderrBuffer' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp,-warnings-as-errors]

!Line: 110 - note: possibly throwing constructor declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 93 to 98 in a510014

TestCase::stdoutOriginal =
no_destroy<unique_ptr<streambuf, void(*)(streambuf*)>>(
unique_ptr<streambuf, void(*)(streambuf*)>(
nullptr, [](streambuf*){}
)
); 

!Line: 93 - error: initialization of 'stdoutOriginal' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp,-warnings-as-errors]

!Line: 110 - note: possibly throwing constructor declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 100 to 105 in a510014

TestCase::clogOriginal =
no_destroy<unique_ptr<streambuf, void(*)(streambuf*)>>(
unique_ptr<streambuf, void(*)(streambuf*)>(
nullptr, [](streambuf*){}
)
); 

!Line: 100 - error: initialization of 'clogOriginal' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp,-warnings-as-errors]

!Line: 110 - note: possibly throwing constructor declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 107 to 112 in a510014

TestCase::stderrOriginal =
no_destroy<unique_ptr<streambuf, void(*)(streambuf*)>>(
unique_ptr<streambuf, void(*)(streambuf*)>(
nullptr, [](streambuf*){}
)
); 

!Line: 107 - error: initialization of 'stderrOriginal' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp,-warnings-as-errors]

!Line: 110 - note: possibly throwing constructor declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 121 to 126 in a510014

this->notifyTestPassed = testPassedMessage;
this->test = std::move(testFn);
this->testName = std::move(name);
if (captureOut) { 

!Line: 121 - error: 'notifyTestPassed' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 123 to 128 in a510014

this->test = std::move(testFn);
this->testName = std::move(name);
if (captureOut) {
captureStdout();
} 

!Line: 123 - error: 'test' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 123 to 128 in a510014

this->test = std::move(testFn);
this->testName = std::move(name);
if (captureOut) {
captureStdout();
} 

!Line: 123 - error: no header providing "std::move" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 124 to 129 in a510014

this->testName = std::move(name);
if (captureOut) {
captureStdout();
}
if (captureLog) { 

!Line: 124 - error: 'testName' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 124 to 129 in a510014

this->testName = std::move(name);
if (captureOut) {
captureStdout();
}
if (captureLog) { 

!Line: 124 - error: no header providing "std::move" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 145 to 150 in a510014

TestCase::TestCase (const TestCase& o) {
this->outCompareOption(o.option);
this->setNotifyPassed(o.notifyTestPassed);
this->pass = o.pass;
this->lastRunTime = o.lastRunTime; 

!Line: 145 - error: parameter name 'o' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 149 to 154 in a510014

this->pass = o.pass;
this->lastRunTime = o.lastRunTime;
this->stdoutCaptured = o.stdoutCaptured;
this->clogCaptured = o.clogCaptured;
this->stderrCaptured = o.stderrCaptured; 

!Line: 149 - error: 'pass' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 150 to 155 in a510014

this->lastRunTime = o.lastRunTime;
this->stdoutCaptured = o.stdoutCaptured;
this->clogCaptured = o.clogCaptured;
this->stderrCaptured = o.stderrCaptured; 

!Line: 150 - error: 'lastRunTime' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 152 to 157 in a510014

this->stdoutCaptured = o.stdoutCaptured;
this->clogCaptured = o.clogCaptured;
this->stderrCaptured = o.stderrCaptured;
if (this->stdoutCaptured) {
captureStdout(); 

!Line: 152 - error: 'stdoutCaptured' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 153 to 158 in a510014

this->clogCaptured = o.clogCaptured;
this->stderrCaptured = o.stderrCaptured;
if (this->stdoutCaptured) {
captureStdout();
} 

!Line: 153 - error: 'clogCaptured' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 154 to 159 in a510014

this->stderrCaptured = o.stderrCaptured;
if (this->stdoutCaptured) {
captureStdout();
}
if (this->clogCaptured) { 

!Line: 154 - error: 'stderrCaptured' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 170 to 175 in a510014

TestCase::TestCase (TestCase&& o) noexcept {
this->option = std::move(o.option);
this->setNotifyPassed(std::move(o.notifyTestPassed));
this->pass = std::move(o.pass); 

!Line: 170 - error: parameter name 'o' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 171 to 176 in a510014

this->option = std::move(o.option);
this->setNotifyPassed(std::move(o.notifyTestPassed));
this->pass = std::move(o.pass);
this->lastRunTime = std::move(o.lastRunTime); 

!Line: 171 - error: 'option' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 171 to 176 in a510014

this->option = std::move(o.option);
this->setNotifyPassed(std::move(o.notifyTestPassed));
this->pass = std::move(o.pass);
this->lastRunTime = std::move(o.lastRunTime); 

!Line: 171 - error: std::move of the expression of the trivially-copyable type 'TestCaseOutCompareOptions' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 171 to 176 in a510014

this->option = std::move(o.option);
this->setNotifyPassed(std::move(o.notifyTestPassed));
this->pass = std::move(o.pass);
this->lastRunTime = std::move(o.lastRunTime); 

!Line: 171 - error: no header providing "std::move" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 173 to 178 in a510014

this->setNotifyPassed(std::move(o.notifyTestPassed));
this->pass = std::move(o.pass);
this->lastRunTime = std::move(o.lastRunTime);
this->stdoutCaptured = std::move(o.stdoutCaptured); 

!Line: 173 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 173 to 178 in a510014

this->setNotifyPassed(std::move(o.notifyTestPassed));
this->pass = std::move(o.pass);
this->lastRunTime = std::move(o.lastRunTime);
this->stdoutCaptured = std::move(o.stdoutCaptured); 

!Line: 173 - error: no header providing "std::move" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 175 to 180 in a510014

this->pass = std::move(o.pass);
this->lastRunTime = std::move(o.lastRunTime);
this->stdoutCaptured = std::move(o.stdoutCaptured);
this->clogCaptured = std::move(o.clogCaptured);
this->stderrCaptured = std::move(o.stderrCaptured); 

!Line: 175 - error: 'pass' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 175 to 180 in a510014

this->pass = std::move(o.pass);
this->lastRunTime = std::move(o.lastRunTime);
this->stdoutCaptured = std::move(o.stdoutCaptured);
this->clogCaptured = std::move(o.clogCaptured);
this->stderrCaptured = std::move(o.stderrCaptured); 

!Line: 175 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 176 to 181 in a510014

this->lastRunTime = std::move(o.lastRunTime);
this->stdoutCaptured = std::move(o.stdoutCaptured);
this->clogCaptured = std::move(o.clogCaptured);
this->stderrCaptured = std::move(o.stderrCaptured); 

!Line: 176 - error: 'lastRunTime' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 176 to 181 in a510014

this->lastRunTime = std::move(o.lastRunTime);
this->stdoutCaptured = std::move(o.stdoutCaptured);
this->clogCaptured = std::move(o.clogCaptured);
this->stderrCaptured = std::move(o.stderrCaptured); 

!Line: 176 - error: std::move of the expression of the trivially-copyable type 'long long' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 176 to 181 in a510014

this->lastRunTime = std::move(o.lastRunTime);
this->stdoutCaptured = std::move(o.stdoutCaptured);
this->clogCaptured = std::move(o.clogCaptured);
this->stderrCaptured = std::move(o.stderrCaptured); 

!Line: 176 - error: no header providing "std::move" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 178 to 183 in a510014

this->stdoutCaptured = std::move(o.stdoutCaptured);
this->clogCaptured = std::move(o.clogCaptured);
this->stderrCaptured = std::move(o.stderrCaptured);
if (this->stdoutCaptured) {
captureStdout(); 

!Line: 178 - error: 'stdoutCaptured' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 178 to 183 in a510014

this->stdoutCaptured = std::move(o.stdoutCaptured);
this->clogCaptured = std::move(o.clogCaptured);
this->stderrCaptured = std::move(o.stderrCaptured);
if (this->stdoutCaptured) {
captureStdout(); 

!Line: 178 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 179 to 184 in a510014

this->clogCaptured = std::move(o.clogCaptured);
this->stderrCaptured = std::move(o.stderrCaptured);
if (this->stdoutCaptured) {
captureStdout();
} 

!Line: 179 - error: 'clogCaptured' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 179 to 184 in a510014

this->clogCaptured = std::move(o.clogCaptured);
this->stderrCaptured = std::move(o.stderrCaptured);
if (this->stdoutCaptured) {
captureStdout();
} 

!Line: 179 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 180 to 185 in a510014

this->stderrCaptured = std::move(o.stderrCaptured);
if (this->stdoutCaptured) {
captureStdout();
}
if (this->clogCaptured) { 

!Line: 180 - error: 'stderrCaptured' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 180 to 185 in a510014

this->stderrCaptured = std::move(o.stderrCaptured);
if (this->stdoutCaptured) {
captureStdout();
}
if (this->clogCaptured) { 

!Line: 180 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 232 to 237 in a510014

TestCase& TestCase::operator= (const TestCase& rhs) {
this->outCompareOption(rhs.option);
this->setNotifyPassed(rhs.notifyTestPassed);
this->pass = rhs.pass;
this->lastRunTime = rhs.lastRunTime; 

!Line: 232 - error: operator=() does not handle self-assignment properly [cert-oop54-cpp,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 232 to 237 in a510014

TestCase& TestCase::operator= (const TestCase& rhs) {
this->outCompareOption(rhs.option);
this->setNotifyPassed(rhs.notifyTestPassed);
this->pass = rhs.pass;
this->lastRunTime = rhs.lastRunTime; 

!Line: 232 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 259 to 264 in a510014

TestCase& TestCase::operator= (TestCase&& rhs) noexcept {
this->option = std::move(rhs.option);
this->setNotifyPassed(std::move(rhs.notifyTestPassed));
this->pass = std::move(rhs.pass); 

!Line: 259 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 260 to 265 in a510014

this->option = std::move(rhs.option);
this->setNotifyPassed(std::move(rhs.notifyTestPassed));
this->pass = std::move(rhs.pass);
this->lastRunTime = std::move(rhs.lastRunTime); 

!Line: 260 - error: std::move of the expression of the trivially-copyable type 'TestCaseOutCompareOptions' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 262 to 267 in a510014

this->setNotifyPassed(std::move(rhs.notifyTestPassed));
this->pass = std::move(rhs.pass);
this->lastRunTime = std::move(rhs.lastRunTime);
this->stdoutCaptured = std::move(rhs.stdoutCaptured); 

!Line: 262 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 264 to 269 in a510014

this->pass = std::move(rhs.pass);
this->lastRunTime = std::move(rhs.lastRunTime);
this->stdoutCaptured = std::move(rhs.stdoutCaptured);
this->clogCaptured = std::move(rhs.clogCaptured);
this->stderrCaptured = std::move(rhs.stderrCaptured); 

!Line: 264 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 265 to 270 in a510014

this->lastRunTime = std::move(rhs.lastRunTime);
this->stdoutCaptured = std::move(rhs.stdoutCaptured);
this->clogCaptured = std::move(rhs.clogCaptured);
this->stderrCaptured = std::move(rhs.stderrCaptured); 

!Line: 265 - error: std::move of the expression of the trivially-copyable type 'long long' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 267 to 272 in a510014

this->stdoutCaptured = std::move(rhs.stdoutCaptured);
this->clogCaptured = std::move(rhs.clogCaptured);
this->stderrCaptured = std::move(rhs.stderrCaptured);
if (this->stdoutCaptured) {
captureStdout(); 

!Line: 267 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 268 to 273 in a510014

this->clogCaptured = std::move(rhs.clogCaptured);
this->stderrCaptured = std::move(rhs.stderrCaptured);
if (this->stdoutCaptured) {
captureStdout();
} 

!Line: 268 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 269 to 274 in a510014

this->stderrCaptured = std::move(rhs.stderrCaptured);
if (this->stdoutCaptured) {
captureStdout();
}
if (this->clogCaptured) { 

!Line: 269 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 287 to 292 in a510014

long long TestCase::getLastRuntime () const {
return this->lastRunTime;
}
void TestCase::logFailure(ostream& out, const string& failureReason) const {
out << fixed; 

!Line: 287 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 299 to 304 in a510014

<< endl;
out << TCPPStr::REASON_ << failureReason << endl;
}
void TestCase::logTestFailure (const string& failureReason) {
unique_ptr<ostream> logStream = nullptr; 

!Line: 299 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 300 to 305 in a510014

out << TCPPStr::REASON_ << failureReason << endl;
}
void TestCase::logTestFailure (const string& failureReason) {
unique_ptr<ostream> logStream = nullptr; 

!Line: 300 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 306 to 311 in a510014

if (this->clogOriginal.get() != nullptr) {
logStream = unique_ptr<ostream>(
new ostream(this->clogOriginal.get().get())
);
}
else { 

!Line: 306 - error: static member accessed through instance [readability-static-accessed-through-instance,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 308 to 313 in a510014

new ostream(this->clogOriginal.get().get())
);
}
else {
logStream = unique_ptr<ostream>(&clog);
} 

!Line: 308 - error: static member accessed through instance [readability-static-accessed-through-instance,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 317 to 322 in a510014

if (this->clogOriginal.get() != nullptr) {
logStream->flush();
// If someone is looking for something in the message,
// and it's captured, make sure it's there.
logFailure(clog, failureReason); 

!Line: 317 - error: static member accessed through instance [readability-static-accessed-through-instance,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 325 to 330 in a510014

logStream.release();
logStream.reset();
}
void TestCase::runTest () {
clog << TCPPStr::START_RUN << this->testName << endl; 

!Line: 325 - error: the value returned by this function should not be disregarded; neglecting it may lead to errors [bugprone-unused-return-value,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 330 to 335 in a510014

clog << TCPPStr::START_RUN << this->testName << endl;
this->lastRunTime = duration(this->test).count();
if (this->notifyTestPassed) {
clog << fixed;
clog << setprecision(TCPPNum::TIME_PRECISION);
clog << TCPPStr::TEST << this->testName << TCPPStr::PASS 

!Line: 330 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 340 to 345 in a510014

<< endl;
}
this->pass = true;
}
bool TestCase::go () { 

!Line: 340 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 345 to 350 in a510014

bool TestCase::go () {
try {
runTest();
return true;
}
catch(const char * errorMessage) { 

!Line: 345 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 374 to 379 in a510014

void TestCase::captureStdout () {
if (TestCase::stdoutCaptureCasesConstructed ==
TestCase::stdoutCaptureCasesDestroyed)
{
TestCase::stdoutCaptureCasesConstructed += 1;
TestCase::stdoutBuffer = 

!Line: 374 - error: method 'captureStdout' can be made static [readability-convert-member-functions-to-static,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 398 to 403 in a510014

void TestCase::captureClog () {
if (TestCase::logCaptureCasesConstructed ==
TestCase::logCaptureCasesDestroyed)
{
TestCase::logCaptureCasesConstructed += 1;
TestCase::clogBuffer = 

!Line: 398 - error: method 'captureClog' can be made static [readability-convert-member-functions-to-static,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 422 to 427 in a510014

void TestCase::captureStdErr () {
if (TestCase::stderrCaptureCasesConstructed ==
TestCase::stderrCaptureCasesDestroyed)
{
TestCase::stderrCaptureCasesConstructed += 1;
TestCase::stderrBuffer = 

!Line: 422 - error: method 'captureStdErr' can be made static [readability-convert-member-functions-to-static,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 478 to 483 in a510014

bool TestCase::checkStdout (const string& against) {
return checkOutput(TestCase::stdoutBuffer.get()->str(),
against);
}
bool TestCase::checkLog (const string& against) { 

!Line: 478 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 483 to 488 in a510014

bool TestCase::checkLog (const string& against) {
return checkOutput(TestCase::clogBuffer.get()->str(),
against);
}
bool TestCase::checkStderr (const string& against) { 

!Line: 483 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 488 to 493 in a510014

bool TestCase::checkStderr (const string& against) {
return checkOutput(TestCase::stderrBuffer.get()->str(),
against);
}
bool TestCase::checkOutput (const string& source, const string& against) 

!Line: 488 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 493 to 498 in a510014

bool TestCase::checkOutput (const string& source, const string& against)
{
switch (this->option) {
case EXACT:
if (source == against) {
return true; 

!Line: 493 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 506 to 511 in a510014

if (this->clogOriginal.get() != nullptr) {
ostream tmp(this->clogOriginal.get().get());
tmp << nomatch.str() << endl;
tmp.flush();
}
else { 

!Line: 506 - error: static member accessed through instance [readability-static-accessed-through-instance,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 507 to 512 in a510014

ostream tmp(this->clogOriginal.get().get());
tmp << nomatch.str() << endl;
tmp.flush();
}
else {
clog << nomatch.str() << endl; 

!Line: 507 - error: static member accessed through instance [readability-static-accessed-through-instance,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 508 to 513 in a510014

tmp << nomatch.str() << endl;
tmp.flush();
}
else {
clog << nomatch.str() << endl;
} 

!Line: 508 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 512 to 517 in a510014

clog << nomatch.str() << endl;
}
return false;
} 

!Line: 512 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 528 to 533 in a510014

if (this->clogOriginal.get() != nullptr) {
ostream tmp(this->clogOriginal.get().get());
tmp << nomatch.str() << endl;
tmp.flush();
}
else { 

!Line: 528 - error: static member accessed through instance [readability-static-accessed-through-instance,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 529 to 534 in a510014

ostream tmp(this->clogOriginal.get().get());
tmp << nomatch.str() << endl;
tmp.flush();
}
else {
clog << nomatch.str() << endl; 

!Line: 529 - error: static member accessed through instance [readability-static-accessed-through-instance,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 530 to 535 in a510014

tmp << nomatch.str() << endl;
tmp.flush();
}
else {
clog << nomatch.str() << endl;
} 

!Line: 530 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 534 to 539 in a510014

clog << nomatch.str() << endl;
}
return false;
} 

!Line: 534 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 541 to 546 in a510014

stringstream re;
re << TCPPStr::UNK_CMP_OPT << this->option;
throw TestCPPException(re.str());
}
}
} 

!Line: 541 - error: variable name 're' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 79 to 84 in a510014

TestSuite (TestObjName&& newSuiteName,
typename enable_if<sizeof...(TestType) == 0>::type)
{
commonInit(std::forward<TestObjName>(newSuiteName));
} 

!Line: 79 - error: constructor does not initialize these fields: firstRun, testSuitePassedMessage, lastRunSucceeded, lastRunSuccessCount, lastRunFailCount, totalRuntime [cppcoreguidelines-pro-type-member-init,hicpp-member-init,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 79 to 84 in a510014

TestSuite (TestObjName&& newSuiteName,
typename enable_if<sizeof...(TestType) == 0>::type)
{
commonInit(std::forward<TestObjName>(newSuiteName));
} 

!Line: 79 - error: rvalue reference parameter 'newSuiteName' is never moved from inside the function body [cppcoreguidelines-rvalue-reference-param-not-moved,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 80 to 85 in a510014

typename enable_if<sizeof...(TestType) == 0>::type)
{
commonInit(std::forward<TestObjName>(newSuiteName));
}
/** 

!Line: 80 - error: all parameters should be named in a function [hicpp-named-parameter,readability-named-parameter,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 90 to 95 in a510014

TestSuite (TestObjName&& newSuiteName, TestType ...tests)
{
commonInit(std::forward<TestObjName>(newSuiteName));
this->addTests(tests...);
} 

!Line: 90 - error: constructor does not initialize these fields: firstRun, testSuitePassedMessage, lastRunSucceeded, lastRunSuccessCount, lastRunFailCount, totalRuntime [cppcoreguidelines-pro-type-member-init,hicpp-member-init,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 90 to 95 in a510014

TestSuite (TestObjName&& newSuiteName, TestType ...tests)
{
commonInit(std::forward<TestObjName>(newSuiteName));
this->addTests(tests...);
} 

!Line: 90 - error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [hicpp-explicit-conversions,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 90 to 95 in a510014

TestSuite (TestObjName&& newSuiteName, TestType ...tests)
{
commonInit(std::forward<TestObjName>(newSuiteName));
this->addTests(tests...);
} 

!Line: 90 - error: rvalue reference parameter 'newSuiteName' is never moved from inside the function body [cppcoreguidelines-rvalue-reference-param-not-moved,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 112 to 117 in a510014

static inline addTests () { }
/**
* @brief Add one or more tests at once to the test suite.
* @param test The first test to add.
* @param tests The rest of the tests to add. 

!Line: 112 - error: function 'addTests' has inline specifier but is implicitly inlined [readability-redundant-inline-specifier,-warnings-as-errors]



!Maximum character count per GitHub comment has been reached! Not all warnings/errors has been parsed!

@codecov
Copy link

codecov bot commented Jun 9, 2025 •
edited
Loading

Codecov Report

All modified and coverable lines are covered by tests ✅

Project coverage is 87.44%. Comparing base (64a90a1) to head (a510014).
Report is 1 commits behind head on main.

✅ All tests successful. No failed tests found.

Additional details and impacted files 
@@           Coverage Diff           @@
##             main     #135   +/-   ##
=======================================
  Coverage   87.44%   87.44%           
=======================================
  Files          10       10           
  Lines         486      486           
  Branches       61       61           
=======================================
  Hits          425      425           
  Misses         52       52           
  Partials        9        9

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

@eljonny eljonny merged commit 9fe54ee into main Jun 9, 2025
42 of 43 checks passed
@eljonny eljonny deleted the update-clang-tidy-and-msvc-with-git-submodules-include-paths branch June 9, 2025 04:15
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

No reviews

Assignees

@eljonny eljonny

Labels

bug Something isn't working ci-cd Relates to CI/CD for the project cmake Applicable to issues that are relavent to the CMake build static-analysis An issue related to a static analysis result

Projects

None yet

Milestone

0.5-release

Development

Successfully merging this pull request may close these issues.

1 participant

@eljonny